Something to note here:

In each case, I'm allowing someone to pass in an Array (for Schedule) or Hash (for Recurrence).

I started writing specific spec cases for this, but I couldn't get minitest to operate how I would have expected it to.

schedule = new_schedule.tap do |schedule|
  schedule << {every: :month}
  schedule << {every: :day}
end

identical_array = [
  {every: :month},
  {every: :day}
]

schedule == identical_array # => true
assert_equal schedule, identical_array # => true

_(schedule).must_equal identical_array # => 💣 

I'd love to add specs here - but I'm not quite sure why .must_equal is having this effect, as I've (perhaps wrongly) assumed that assert_equal and must_equal are identical:

https://github.com/seattlerb/minitest/blob/3c6576a51f4e266996e3459d7a0dd054eb4c87f7/lib/minitest/expectations.rb#L38

Thank you for the PR! I like the idea of implementing #== for Schedule and Recurrence.

I don't think we will equate with Array and Hash. Callers can still cast accordingly, e.g., schedule == Schedule.new(array) and recurrence == Recurrence.new(hash).

As for the Schedule implementation, how about we delegate to Recurrence#==, something like this:

def ==(other)
  if other.is_a?(self.class)
    all?(&:==)
  else
    super
  end
end

Just offering some drive-by feedback on this while I'm evaluating using montrose in my project.

A coercion method would be useful here to convert the other object so that you can depend on the methods defined there.

def ==(other)
  Recurrence(other).all?(&:==)
end

That method might look like:

def Recurrence(object)
  if object.is_a?(Recurrence)
    return object
  else
    Montrose.recurrence(object)
  end
end

The same could be done for Schedule. I'm not sure if that implementation is exactly correct for this library but it would function like the Array() method.

EDIT: Here's how I'm patching this with an initializer

require "montrose"

module RecurrenceComparision
  def ==(other)
    Montrose.recurrence(other).to_hash == to_hash
  end
end
Montrose::Recurrence.prepend(RecurrenceComparision)